package com.likeycy.my;

/**
 * @ClassName: Test1
 * @Description: 估算每个方法执行所需要的时间复杂度和空间复杂度
 * @Author: sodagreen
 * @Date: 2021/2/20 5:18
 * @Version: 1.0
 */
public class Test1 {

    public static void test1(int n) {
        /*
         所需执行的指令次数： if为1次，for循环为13次（i赋值1次，i判断4次，i++4次）, sys语句执行 4 次
         公式计算 ：1 + 1 + 4 + 4 + 4
         总共约执行指令次数：14
         */
        // 时间复杂度大O表示法：O(1)
        if (n > 10) {
            System.out.println("n > 10");
        } else if (n > 5) {
            System.out.println("n > 5");
        } else {
            System.out.println("n <= 5");
        }

        for (int i = 0; i < 4; i++) {
            System.out.println("test1");
        }
    }

    public static void test2(int n) {
        /*
          所需执行的指令次数：for循环为 n 次（i赋值 1次，i判断 n 次，i++ n 次）, sys语句执行 n 次
          公式计算 ：1 + n + n + n
          总共约执行指令次数： 1 + 3n
         */
        // 时间复杂度大O表示法：O(n)
        for (int i = 0; i < n; i++) {
            System.out.println("test2");
        }
    }

    public static void test3(int n) {
        /*
         所需执行的指令次数： 外层for循环执行 1 + 2n 次，内层for循环执行 n * (1 + 3n)
         公式计算 ：1 + 2n + n * (1 + 3n)
         总共约执行指令次数：1 + 3n + 3n^2
         */
        // 时间复杂度大O表示法：O(n^2)
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.println("test3");
            }
        }
    }

    public static void test4(int n) {
        /*
         所需执行的指令次数： 外层for循环执行 1 + 2n 次，内层for循环执行 n * (1 + 45)
         公式计算 ：1 + 2n + n * (1 + 45)
         总共约执行指令次数：1 + 2n + 46n = 48n + 1
         */
        // 时间复杂度大O表示法：O(n)
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 15; j++) {
                System.out.println("test4");
            }
        }
    }

    public static void test5(int n) {
        /*
          参数为8，执行3次：8 = 2^3
          3 = log2(8)
          参数为16，执行4次：16 = 2^4
          4 = log2(16)
         总共约执行指令次数：log2(n) (对数叫法：以 2为 底n 的对数)
         */
        // 时间复杂度大O表示法：O(logn)
        while ((n = n / 2) > 0) {
            System.out.println("test5");
        }
    }

    public static void test6(int n) {
        /*
         总共约执行指令次数：log5(n) (对数叫法：以 5 为 底n 的对数)
         */
        // 时间复杂度大O表示法：O(logn)
        while ((n = n / 5) > 0) {
            System.out.println("test6");
        }
    }

    public static void test7(int n) {
        /*
         所需执行的指令次数： 外层for循环执行 1 + 2 * log2(n) 次，内层for循环执行 log2(n) * (1 + 3n)
         公式计算 ：1 + 2 * log2(n) + log2(n) * (1 + 3n)
         总共约执行指令次数：1 + 3 * log2(n) + 2 * nlog2(n)
         */
        // 时间复杂度大O表示法：O(logn + nlogn) = O(nlogn)
        for (int i = 1; i < n; i = i + i) {
            for (int j = 0; j < n; j++) {
                System.out.println("test7");
            }
        }
    }

    public static void test10(int n) {
        // 时间复杂度表示法：1 + 1 + 1 + n + 1 + 3n = 4 + 4n = O(n)
        // 空间复杂度大O表示法：O(n)
        int a = 10;
        int b = 20;
        int c = a + b;
        int[] array = new int[n];
        for (int i = 0; i < array.length; i++) {
            System.out.println("test10");
        }
    }
}
